import unittest
import transaction
from pyramid import testing


def _initTestingDB():
    from sqlalchemy import create_engine
    from alpha.modelos.models import (
        DBSession,
        Usuario,
        Rol,
        Base
        )
    engine = create_engine('sqlite:///:memory:')
    Base.metadata.create_all(engine)
    DBSession.configure(bind=engine)
    with transaction.manager:
        model = Usuario( 'carlos', 'carlos', 'carlos', 'carlos', 22, 22, 'aquinoqcd29@gmail.com')
        DBSession.add(model)
    return DBSession

class UsuariolTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Usuario
        return Usuario

    def _makeOne(self, nombreUsuario= 'nombreUsuario', password='password', nombre='nombre', apellido='apellido', telefono=22, nroDocumento=22, mail='mail@gmail.com'):
        return self._getTargetClass()(nombreUsuario, password, nombre, apellido, telefono, nroDocumento, mail)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombreUsuario, 'nombreUsuario')
        self.assertEqual(instance.nombre, 'nombre')
        self.assertEqual(instance.apellido, 'apellido')
        self.assertEqual(instance.telefono, 22)
        self.assertEqual(instance.nroDocumento, 22)
        self.assertEqual(instance.mail, 'mail@gmail.com')
        print 'Prueba de agregar Usuario: Ok'

class RollTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Rol
        return Rol

    def _makeOne(self, nombre= 'nombreRol', descripcion='descripcion'):
        return self._getTargetClass()(nombre, descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'nombreRol')
        print 'Prueba de agregar Rol: Ok'

class ProyectolTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Proyecto
        return Proyecto

    def _makeOne(self, nombre= 'AM', descripcion= 'Gestor'):
        return self._getTargetClass()(nombre, descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'AM')
        self.assertEqual(instance.descripcion, 'Gestor')
        print 'Prueba de agregar Proyecto: Ok'

class FaselTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Fase
        return Fase

    def _makeOne(self, nombre= 'analisis', descripcion= 'hola'):
        return self._getTargetClass()(nombre,descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'analisis')
        self.assertEqual(instance.descripcion,'hola')
        print 'Prueba de agregar Fase: Ok'

class TipoItemlTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import TipoItem
        return TipoItem

    def _makeOne(self, nombre= 'planilla',descripcion='hola'):
        return self._getTargetClass()(nombre,descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'planilla')
        self.assertEqual(instance.descripcion, 'hola')
        print 'Prueba de agregar Tipo de Items: Ok'


class AsociacionRolProyectotests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import AsociacionRolProyecto
        return AsociacionRolProyecto

    def _makeOne(self):
        return self._getTargetClass()()

    def test_constructor(self):
        instance = self._makeOne()
        print 'Prueba de Asociacion de Rol por Proyecto: Ok'

class AssociationlTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import AsociacionRolFase
        return AsociacionRolFase

    def _makeOne(self):
        return self._getTargetClass()()

    def test_constructor(self):
        instance = self._makeOne()
        print 'Prueba de Asociacion de Rol por Fase: Ok'
       
class atributoTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Atributo
        return Atributo

    def _makeOne(self, nombre= 'nombreAtributo', descripcion='descripcion'):
        return self._getTargetClass()(nombre, descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'nombreAtributo')
        print 'Prueba de agregar Atributo: Ok'

class permisoTests(unittest.TestCase):

    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        self.session.remove()

    def _getTargetClass(self):
        from alpha.modelos.models import Permiso
        return Permiso

    def _makeOne(self, nombre= 'nombrePermiso', descripcion='descripcion'):
        return self._getTargetClass()(nombre, descripcion)

    def test_constructor(self):
        instance = self._makeOne()
        self.assertEqual(instance.nombre, 'nombrePermiso')
        print 'Prueba de agregar Permiso: Ok'
